SonarSource Rules
  • Products

    In-IDE

    Code Quality and Security in your IDE with SonarQube Ide

    IDE extension that lets you fix coding issues before they exist!

    Discover SonarQube for IDE

    SaaS

    Code Quality and Security in the cloud with SonarQube Cloud

    Setup is effortless and analysis is automatic for most languages

    Discover SonarQube Cloud

    Self-Hosted

    Code Quality and Security Self-Hosted with SonarQube Server

    Fast, accurate analysis; enterprise scalability

    Discover SonarQube Server
  • SecretsSecrets
  • ABAPABAP
  • AnsibleAnsible
  • ApexApex
  • AzureResourceManagerAzureResourceManager
  • CC
  • C#C#
  • C++C++
  • CloudFormationCloudFormation
  • COBOLCOBOL
  • CSSCSS
  • DartDart
  • DockerDocker
  • FlexFlex
  • GitHub ActionsGitHub Actions
  • GoGo
  • HTMLHTML
  • JavaJava
  • JavaScriptJavaScript
  • JSONJSON
  • JCLJCL
  • KotlinKotlin
  • KubernetesKubernetes
  • Objective CObjective C
  • PHPPHP
  • PL/IPL/I
  • PL/SQLPL/SQL
  • PythonPython
  • RPGRPG
  • RubyRuby
  • RustRust
  • ScalaScala
  • ShellShell
  • SwiftSwift
  • TerraformTerraform
  • TextText
  • TypeScriptTypeScript
  • T-SQLT-SQL
  • VB.NETVB.NET
  • VB6VB6
  • XMLXML
  • YAMLYAML
Rust

Rust static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your RUST code

  • All rules 85
  • Bug60
  • Code Smell25

  • Quick Fix 4
 
Tags
    Impact
      Clean code attribute
        1. Match expression conditions should not have boolean type

           Code Smell
        2. Pointer arithmetic should not be performed on zero-sized types

           Code Smell
        3. Shared code in all branches should be extracted

           Code Smell
        4. Inline vector literals should be preferred to chains of insertions

           Code Smell
        5. Mathematical constants should not be hardcoded

           Code Smell
        6. "std::ptr::null" should be used to denote the null pointer

           Code Smell
        7. Redundant casts should be avoided

           Code Smell
        8. Cognitive Complexity of functions should not be too high

           Code Smell
        9. Array elements should be separated by commas

           Code Smell
        10. Field init shorthand should be used

           Code Smell
        11. Boolean expressions should not be gratuitous

           Code Smell
        12. Invisible Unicode characters should not be used

           Code Smell
        13. Unnecessary bit operations should not be performed

           Code Smell
        14. Rust source files should not have syntax errors

           Code Smell
        15. Wildcard imports should not be used

           Code Smell
        16. Unnecessary mathematical comparisons should not be made

           Code Smell
        17. Erasing mathematical operations should not be performed

           Code Smell
        18. Underscores should be used to make large numbers readable

           Code Smell
        19. "to_string()" should never be called on a String value

           Code Smell
        20. Closures should be replaced with function pointers

           Code Smell
        21. Local variables should not be declared and then immediately returned

           Code Smell
        22. "if ... else if" constructs should end with "else" clauses

           Code Smell
        23. Empty statements should be removed

           Code Smell
        24. Functions should not have too many parameters

           Code Smell
        25. Standard outputs should not be used directly to log anything

           Code Smell

        Cognitive Complexity of functions should not be too high

        adaptability - focused
        maintainability
        Code Smell
        • brain-overload

        This rule raises an issue when the code cognitive complexity of a function is above a certain threshold.

        Why is this an issue?

        More Info

        Cognitive Complexity is a measure of how hard it is to understand the control flow of a unit of code. Code with high cognitive complexity is hard to read, understand, test, and modify.

        As a rule of thumb, high cognitive complexity is a sign that the code should be refactored into smaller, easier-to-manage pieces.

        Which syntax in code does impact cognitive complexity score?

        Here are the core concepts:

        • Cognitive complexity is incremented each time the code breaks the normal linear reading flow.
          This concerns, for example, loop structures, conditionals, catches, switches, jumps to labels, and conditions mixing multiple operators.
        • Each nesting level increases complexity.
          During code reading, the deeper you go through nested layers, the harder it becomes to keep the context in mind.
        • Method calls are free
          A well-picked method name is a summary of multiple lines of code. A reader can first explore a high-level view of what the code is performing then go deeper and deeper by looking at called functions content.
          Note: This does not apply to recursive calls, those will increment cognitive score.

        The method of computation is fully detailed in the pdf linked in the resources.

        What is the potential impact?

        Developers spend more time reading and understanding code than writing it. High cognitive complexity slows down changes and increases the cost of maintenance.

          Available In:
        • SonarQube CloudDetect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

        © 2008-2025 SonarSource SA. All rights reserved.

        Privacy Policy | Cookie Policy | Terms of Use